home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / asxsrc.arc / LKLIST.C < prev    next >
C/C++ Source or Header  |  1989-08-25  |  4KB  |  213 lines
  1. /* lklist.c */
  2.  
  3. /*
  4.  * (C) Copyright 1989
  5.  * All Rights Reserved
  6.  *
  7.  * Alan R. Baldwin
  8.  * 721 Berkeley St.
  9.  * Kent, Ohio  44240
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include "aslink.h"
  14.  
  15. /*
  16.  * Increment the count of lines on the
  17.  * page. If the page overflows put out a page
  18.  * skip and linker header.
  19.  */
  20. VOID
  21. slew(fp)
  22. FILE *fp;
  23. {
  24.     register i;
  25.  
  26.     if (lop++ >= NLPP) {
  27.         newpag(fp);
  28.         if (xflag == 0) {
  29.             fprintf(fp, "Hexidecimal\n\n");
  30.         } else
  31.         if (xflag == 1) {
  32.             fprintf(fp, "Octal\n\n");
  33.         } else
  34.         if (xflag == 2) {
  35.             fprintf(fp, "Decimal\n\n");
  36.         }
  37.         fprintf(fp, "Area       Addr   Size");
  38.         fprintf(fp, "   Decimal Bytes (Attributes)\n");
  39.         for(i=0;i<4;++i)
  40.             fprintf(fp, "      Value--Global");
  41.         fprintf(fp, "\n\n");
  42.         lop += 6;
  43.     }
  44. }
  45.  
  46. /*
  47.  * New Page
  48.  */
  49. VOID
  50. newpag(fp)
  51. FILE *fp;
  52. {
  53.     fprintf(fp, "\faslink,  page %u.\n", ++page);
  54.     lop = 1;
  55. }
  56.  
  57. /*
  58.  * Area Map Output
  59.  */
  60. VOID
  61. lstarea(rp)
  62. struct area *rp;
  63. {
  64.     register struct area *op;
  65.     register struct areax *oxp;
  66.     register c, i, j;
  67.     register char *ptr;
  68.     int nmsym;
  69.     addr_t a0, ai;
  70.     struct sym *sp;
  71.     struct sym **p;
  72.  
  73.     putc('\n', mfp);
  74.     slew(mfp);
  75.     /*
  76.      * Output Area Header
  77.      */
  78.     ptr = &rp->a_id[0];
  79.     while (ptr < &rp->a_id[NCPS]) {
  80.         if (c = *ptr++) {
  81.             putc(c, mfp);
  82.         } else {
  83.             putc(' ', mfp);
  84.         }
  85.     }
  86.     i = rp->a_addr;
  87.     j = rp->a_size;
  88.     if (xflag == 0) {
  89.         fprintf(mfp, "   %04X   %04X", i, j);
  90.     } else
  91.     if (xflag == 1) {
  92.         fprintf(mfp, " %06o %06o", i, j);
  93.     } else
  94.     if (xflag == 2) {
  95.         fprintf(mfp, "  %05u  %05u", i, j);
  96.     }
  97.     fprintf(mfp, " = %6u. bytes ", j);
  98.     if (rp->a_flag & A_ABS) {
  99.         fprintf(mfp, "(ABS");
  100.     } else {
  101.         fprintf(mfp, "(REL");
  102.     }
  103.     if (rp->a_flag & A_OVR) {
  104.         fprintf(mfp, ",OVR)");
  105.     } else {
  106.         fprintf(mfp, ",CON)");
  107.     }
  108.  
  109.     /*
  110.      * Find number of symbols in area
  111.      */
  112.     nmsym = 0;
  113.     oxp = rp->a_axp;
  114.     while (oxp) {
  115.         for (i=0; i<NHASH; i++) {
  116.             sp = symhash[i];
  117.             while (sp != NULL) {
  118.                 if (oxp == sp->s_axp)
  119.                     ++nmsym;
  120.                 sp = sp->s_sp;
  121.             }
  122.         }
  123.         oxp = oxp->a_axp;
  124.     }
  125.     if (nmsym == 0) {
  126.         putc('\n', mfp);
  127.         slew(mfp);
  128.         return;
  129.     }
  130.  
  131.     /*
  132.      * Allocate space for an array of pointers to symbols
  133.      * and load array.
  134.      */
  135.     if ( (p = (struct sym **) malloc(nmsym*sizeof(struct sym *)))
  136.         == NULL) {
  137.         fprintf(mfp, "\nInsufficient space to build Map Segment.\n");
  138.         slew(mfp);
  139.         return;
  140.     }
  141.     nmsym = 0;
  142.     oxp = rp->a_axp;
  143.     while (oxp) {
  144.         for (i=0; i<NHASH; i++) {
  145.             sp = symhash[i];
  146.             while (sp != NULL) {
  147.                 if (oxp == sp->s_axp) {
  148.                     p[nmsym++] = sp;
  149.                 }
  150.                 sp = sp->s_sp;
  151.             }
  152.         }
  153.         oxp = oxp->a_axp;
  154.     }
  155.  
  156.     /*
  157.      * Bubble Sort of Addresses in Symbol Table Array
  158.      */
  159.     j = 1;
  160.     while (j) {
  161.         j = 0;
  162.         sp = p[0];
  163.         a0 = sp->s_addr + sp->s_axp->a_addr;
  164.         for (i=1; i<nmsym; ++i) {
  165.             sp = p[i];
  166.             ai = sp->s_addr + sp->s_axp->a_addr;
  167.             if (a0 > ai) {
  168.                 j = 1;
  169.                 p[i] = p[i-1];
  170.                 p[i-1] = sp;
  171.             }
  172.             a0 = ai;
  173.         }
  174.     }
  175.  
  176.     /*
  177.      * Symbol Table Output
  178.      */
  179.     i = 0;
  180.     while (i < nmsym) {
  181.         if (i % 4 == 0) {
  182.             fprintf(mfp, "\n");
  183.             slew(mfp);
  184.             fprintf(mfp, "     ");
  185.         }
  186.         sp = p[i];
  187.         j = sp->s_addr + sp->s_axp->a_addr;
  188.         if (xflag == 0) {
  189.             fprintf(mfp, "  %04X  ", j);
  190.         } else
  191.         if (xflag == 1) {
  192.             fprintf(mfp, "%06o  ", j);
  193.         } else
  194.         if (xflag == 2) {
  195.             fprintf(mfp, " %05u  ", j);
  196.         }
  197.         ptr = &sp->s_id[0];
  198.         while (ptr < &sp->s_id[NCPS]) {
  199.             if (c = *ptr++) {
  200.                 putc(c, mfp);
  201.             } else {
  202.                 putc(' ', mfp);
  203.             }
  204.         }
  205.         if (++i < nmsym)
  206.             if (i % 4 != 0)
  207.                 fprintf(mfp, " | ");
  208.     }
  209.     putc('\n', mfp);
  210.     free(p);
  211.     slew(mfp);
  212. }
  213.